There's a code duplication issue here. Lines 369-378 (bulk writes scan) are nearly identical to lines 346-354 (append buffer scan). Both loops:

1. Check the same conditions for non-batchable values
2. Collect indices in a list
3. Replace with None in the grid

Consider extracting this into a helper method to avoid duplication and improve maintainability. For example:

def _extract_non_batchable(self, grid: list[list[Any]], start_row: int, start_col: int) -> list[tuple[int, int, Any]]:
    """Extract non-batchable values from grid, replacing them with None."""
    indiv: list[tuple[int, int, Any]] = []
    for ri, row in enumerate(grid):
        for ci, val in enumerate(row):
            if val is not None and (
                isinstance(val, bool)
                or (isinstance(val, str) and val.startswith("="))
                or not isinstance(val, (int, float, str))
            ):
                indiv.append((start_row + ri, start_col + ci, val))
                row[ci] = None
    return indiv

Fixed in a56f0fc. Extracted _extract_non_batchable() static method that both the append buffer and bulk write scanning now call.

Flush write_rows queue when saving in modify mode

write_rows() now queues grids into _bulk_writes, but that queue is only consumed in the writer-specific flush loop shown here. In load_workbook(..., modify=True) flows, _flush() uses the patcher path and never drains _bulk_writes, so ws.write_rows(...) changes are silently dropped on save unless each target cell is also written through the dirty-cell path.

Useful? React with 👍 / 👎.

Fixed in a56f0fc. Added _materialize_bulk_writes() method that converts bulk write buffers into Cell objects. The patcher flush path now calls it (alongside the existing _materialize_append_buffer()) before processing dirty cells. This ensures write_rows() data is flushed in modify mode.

Avoid mutating caller-provided grids during bulk flush

The bulk write flush mutates the original grid in place via row[ci] = None for non-batchable values. Because write_rows() stores the caller's list object directly, this side effect leaks out after save() and can corrupt results when the same grid is reused in multiple write_rows() calls (later writes lose booleans/formulas/dates that were nulled during the first flush).

Useful? React with 👍 / 👎.

Fixed in a56f0fc. write_rows() now stores a shallow copy of the grid ([list(row) for row in rows]) so that the non-batchable extraction in flush can safely mutate row elements without affecting the caller's original lists.

Preserve date/datetime types in values_only bulk reads

The new plain bulk conversion formats Data::DateTime as strings and returns them directly, so the fast iter_rows(values_only=True) path now yields string timestamps instead of the date/datetime objects produced by the existing payload conversion path. This breaks callers that rely on typed date values for comparisons or arithmetic when bulk reads are enabled.

Useful? React with 👍 / 👎.

Fixed in a56f0fc. Updated data_to_plain_py() in Rust to return proper Python datetime.date / datetime.datetime objects using PyO3's PyDate::new() / PyDateTime::new() constructors. Also handles DateTimeIso values with proper midnight detection (returns date vs datetime). This matches the typed behavior of the non-bulk _payload_to_python() path.